home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / clients / bitmap / bitedit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-12  |  27.3 KB  |  1,114 lines
  1. /*
  2.  * $XConsortium: BitEdit.c,v 1.22 91/07/22 19:57:49 keith Exp $
  3.  *
  4.  * Copyright 1989 Massachusetts Institute of Technology
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of M.I.T. not be used in advertising or
  11.  * publicity pertaining to distribution of the software without specific,
  12.  * written prior permission.  M.I.T. makes no representations about the
  13.  * suitability of this software for any purpose.  It is provided "as is"
  14.  * without express or implied warranty.
  15.  *
  16.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  18.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  *
  23.  * Author:  Davor Matic, MIT X Consortium
  24.  */
  25.  
  26.  
  27.  
  28.  
  29. #include <stdio.h>
  30. #ifdef MSDOS
  31. #include "X11/Intrinsc.h"      /* QDK 05/11/1994 10:44am. */
  32. #else
  33. #include "X11/Intrinsic.h"
  34. #endif
  35. #include <X11/StringDefs.h>
  36. #include <X11/Xaw/Paned.h>
  37. #include <X11/Xaw/Form.h>
  38. #include <X11/Xaw/Box.h>
  39. #include <X11/Xaw/Command.h>
  40. #include <X11/Xaw/Toggle.h>
  41. #include <X11/Xaw/MenuButton.h>
  42. #include <X11/Xaw/SimpleMenu.h>
  43. #include <X11/Xaw/SmeLine.h>
  44. #include <X11/Xaw/SmeBSB.h>
  45. #include "Bitmap.h"
  46.  
  47. #include <X11/bitmaps/xlogo16>
  48.  
  49. static char *usage = "[-options ...] filename\n\
  50. \n\
  51. where options include all standard toolkit options plus:\n\
  52.      -size WIDTHxHEIGHT\n\
  53.      -sw dimension\n\
  54.      -sh dimension\n\
  55.      -gt dimension\n\
  56.      -grid, +grid\n\
  57.      -axes, +axes\n\
  58.      -dashed, +dashed\n\
  59.      -stippled, +stippled\n\
  60.      -proportional, +proportional\n\
  61.      -basename basename\n\
  62.      -dashes filename\n\
  63.      -stipple filename\n\
  64.      -hl color\n\
  65.      -fr color\n\
  66. \n\
  67. The default WIDTHxHEIGHT is 16x16.\n";
  68.  
  69. static XrmOptionDescRec options[] = {
  70.   { "-axes",        "*bitmap.axes",        XrmoptionNoArg,    "True"},
  71.   { "+axes",        "*bitmap.axes",        XrmoptionNoArg,    "False"},
  72.   { "-basename",    "*bitmap.basename",        XrmoptionSepArg,    NULL},
  73.   { "-dashed",        "*bitmap.dashed",        XrmoptionNoArg,    "True"},
  74.   { "+dashed",        "*bitmap.dashed",        XrmoptionNoArg,    "False"},
  75.   { "-dashes",        "*bitmap.dashes",        XrmoptionSepArg,    NULL},
  76.   { "-fr",        "*bitmap.frame",        XrmoptionSepArg,    NULL},
  77.   { "-gt",        "*bitmap.gridTolerance",XrmoptionSepArg,    NULL},
  78.   { "-grid",        "*bitmap.grid",        XrmoptionNoArg,    "True"},
  79.   { "+grid",        "*bitmap.grid",        XrmoptionNoArg,    "False"},
  80.   { "-hl",        "*bitmap.highlight",    XrmoptionSepArg,    NULL},
  81.   { "-proportional","*bitmap.proportional", XrmoptionNoArg,    "True"},
  82.   { "+proportional","*bitmap.proportional", XrmoptionNoArg,    "False"},
  83.   { "-size",        "*bitmap.size",        XrmoptionSepArg,    NULL},
  84.   { "-sh",        "*bitmap.squareHeight", XrmoptionSepArg,    NULL},
  85.   { "-sw",        "*bitmap.squareWidth",  XrmoptionSepArg,    NULL},
  86.   { "-stipple",        "*bitmap.stipple",        XrmoptionSepArg,    NULL},
  87.   { "-stippled",    "*bitmap.stippled",        XrmoptionNoArg,    "True"},
  88.   { "+stippled",    "*bitmap.stippled",        XrmoptionNoArg,    "False"},
  89. };
  90.  
  91. typedef struct {
  92.   int             id;
  93.   String          name;
  94.   Boolean         trap;
  95.   Widget          widget;
  96.   } ButtonRec;
  97.  
  98. static ButtonRec file_menu[] = {
  99. #define New 101
  100.   {New, "new", True},
  101. #define Load 102
  102.   {Load, "load", True},
  103. #define Insert 103
  104.   {Insert, "insert", True},
  105. #define Save 104
  106.   {Save, "save", True},
  107. #define SaveAs 105
  108.   {SaveAs, "saveAs", True},
  109. #define Resize 106
  110.   {Resize, "resize", True},
  111. #define Rescale 107
  112.   {Rescale, "rescale", True},
  113. #define Filename 108
  114.   {Filename, "filename", True},
  115. #define Basename 109
  116.   {Basename, "basename", True},
  117. #define Dummy -1
  118.   {Dummy, "line", False},
  119. #define Quit 110
  120.   {Quit, "quit", True},
  121. };
  122.  
  123. static ButtonRec edit_menu[] = {
  124. #define Image 201
  125.   {Image, "image", True},
  126. #define Grid 203
  127.   {Grid, "grid", True},
  128. #define Dashed 204
  129.   {Dashed, "dashed", True},
  130. #define Axes 205
  131.   {Axes, "axes", True},
  132. #define Stippled 206
  133.   {Stippled, "stippled", True},
  134. #define Proportional 207
  135.   {Proportional, "proportional", True},
  136. #define Zoom 208
  137.   {Zoom, "zoom", True},
  138. /* Dummy */
  139.   {Dummy, "line", False},
  140. #define Cut 209
  141.   {Cut, "cut", True},
  142. #define Copy 210
  143.   {Copy, "copy", True},
  144. #define Paste 211
  145.   {Paste, "paste", True},
  146. };
  147.  
  148. static ButtonRec buttons[] = {
  149. /*#define Clear 1*/
  150.   {Clear, "clear", False},
  151. /*#define Set 2*/
  152.   {Set, "set", False},
  153. /*#define Invert 3*/
  154.   {Invert, "invert", False},
  155. #define Mark 26
  156.   {Mark, "mark", True},
  157. #define Unmark 27
  158.   {Unmark, "unmark", False},
  159. #define CopyImm 4
  160.   {CopyImm, "copy", True},
  161. #define MoveImm 5
  162.   {MoveImm, "move", True},
  163. #define FlipHoriz 6
  164.   {FlipHoriz, "flipHoriz", False},
  165. #define Up 7
  166.   {Up, "up", False},
  167. #define FlipVert 8
  168.   {FlipVert, "flipVert", False},
  169. #define Left 9
  170.   {Left, "left", False},
  171. #define Fold 10
  172.   {Fold, "fold", False},
  173. #define Right 11
  174.   {Right, "right", False},
  175. #define RotateLeft 12
  176.   {RotateLeft, "rotateLeft", False},
  177. #define Down 13
  178.   {Down, "down", False},
  179. #define RotateRight 14
  180.   {RotateRight, "rotateRight", False},
  181. #define Point 15
  182.   {Point, "point", True},
  183. #define Curve 16
  184.   {Curve, "curve", True},
  185. #define Line 17
  186.   {Line, "line", True},
  187. #define Rectangle 18
  188.   {Rectangle, "rectangle", True},
  189. #define FilledRectangle 19
  190.   {FilledRectangle, "filledRectangle", True},
  191. #define Circle 20
  192.   {Circle, "circle", True},
  193. #define FilledCircle 21
  194.   {FilledCircle, "filledCircle", True},
  195. #define FloodFill 22
  196.   {FloodFill, "floodFill", True},
  197. #define SetHotSpot 23
  198.   {SetHotSpot, "setHotSpot", True},
  199. #define ClearHotSpot 24
  200.   {ClearHotSpot, "clearHotSpot", False},
  201. #define Undo 25
  202.   {Undo, "undo", False},
  203. };
  204.  
  205. #include "Dialog.h"
  206.  
  207. Widget 
  208.     top_widget, 
  209.     parent_widget,
  210.     formy_widget,
  211.     fileButton_widget, fileMenu_widget,
  212.     editButton_widget, editMenu_widget,
  213.     status_widget,
  214.     pane_widget, 
  215.     form_widget,
  216.     bitmap_widget,
  217.     image_shell,
  218.     box_widget,
  219.     normal_image_widget,
  220.     inverted_image_widget;
  221. Boolean image_visible = False;
  222. Pixmap check_mark;
  223. Dialog input_dialog, error_dialog, qsave_dialog;
  224. Time btime;
  225. String filename = NULL, basename = NULL, format;
  226. char message[80];
  227.  
  228.  
  229. void FixMenu();
  230. void SwitchImage();
  231. void SwitchGrid();
  232. void SwitchDashed();
  233. void SwitchAxes();
  234. void SwitchStippled();
  235. void SwitchProportional();
  236. void SwitchZoom();
  237. void DoCut();
  238. void DoCopy();
  239. void DoPaste();
  240. void DoNew();
  241. void DoLoad();
  242. void DoInsert();
  243. void DoSave();
  244. void DoSaveAs();
  245. void DoResize();
  246. void DoRescale();
  247. void DoFilename();
  248. void DoBasename();
  249. void DoQuit();
  250.  
  251. static XtActionsRec actions_table[] = {
  252.   {"fix-menu", FixMenu},
  253.   {"switch-image", SwitchImage},
  254.   {"switch-grid", SwitchGrid},
  255.   {"switch-dashed", SwitchDashed},
  256.   {"switch-axes", SwitchAxes},
  257.   {"switch-stippled", SwitchStippled},
  258.   {"switch-proportional", SwitchProportional},
  259.   {"switch-zoom", SwitchZoom},
  260.   {"do-cut", DoCut},
  261.   {"do-copy", DoCopy},
  262.   {"do-paste", DoPaste},
  263.   {"do-new", DoNew},
  264.   {"do-load", DoLoad},
  265.   {"do-insert", DoInsert},
  266.   {"do-save", DoSave},
  267.   {"do-save-as", DoSaveAs},
  268.   {"do-resize", DoResize},
  269.   {"do-rescale", DoRescale},
  270.   {"do-filename", DoFilename},
  271.   {"do-basename", DoBasename},
  272.   {"do-quit", DoQuit}
  273. };
  274.  
  275. static Atom wm_delete_window;
  276.  
  277. void FixImage()
  278. {
  279.     Pixmap old_image, image;
  280.     int n;
  281.     Arg wargs[2];
  282.  
  283.     if (!image_visible) return;
  284.     
  285.     n=0;
  286.     XtSetArg(wargs[n], XtNbitmap, &old_image); n++;
  287.     XtGetValues(normal_image_widget, wargs, n);
  288.     
  289.     
  290.     image = BWGetUnzoomedPixmap(bitmap_widget);
  291.     
  292.     n=0;
  293.     XtSetArg(wargs[n], XtNbitmap, image); n++;
  294.     XtSetValues(normal_image_widget, wargs, n);
  295.     XtSetValues(inverted_image_widget, wargs, n);
  296.  
  297.     if (old_image != XtUnspecifiedPixmap)
  298.     XFreePixmap(XtDisplay(bitmap_widget), old_image);
  299. }
  300.  
  301. FixStatus()
  302. {
  303.     int n;
  304.     Arg wargs[2];
  305.     String str, label;
  306.  
  307.     str = BWUnparseStatus(bitmap_widget);
  308.  
  309.     n=0;
  310.     XtSetArg(wargs[n], XtNlabel, &label); n++;
  311.     XtGetValues(status_widget, wargs, n);
  312.  
  313.     if (strcmp(str, label)) {
  314.       n = 0;
  315.       XtSetArg(wargs[n], XtNlabel, str); n++;
  316.       XtSetValues(status_widget, wargs, n);
  317.     }
  318.  
  319.     /*XtFree(str); */
  320. }
  321.  
  322. void FixUp()
  323. {
  324.   FixImage();
  325.   FixStatus();
  326. }
  327.  
  328. void FixEntry(w, id)
  329.     Widget w;
  330.     int *id;
  331. {
  332.     int n;
  333.     Arg wargs[2];
  334.     Time dummy = 0;
  335.  
  336.     n = 0;
  337.     
  338.     switch (*id) {
  339.     
  340.     case Image:
  341.     XtSetArg(wargs[n], XtNleftBitmap, 
  342.          image_visible ? check_mark : None); n++;
  343.     break;
  344.     
  345.     case Grid:
  346.     XtSetArg(wargs[n], XtNleftBitmap, 
  347.          BWQueryGrid(bitmap_widget) ? check_mark : None); n++;
  348.     break;
  349.     
  350.     case Dashed:
  351.     XtSetArg(wargs[n], XtNleftBitmap, 
  352.          BWQueryDashed(bitmap_widget) ? check_mark : None); n++;
  353.     break;
  354.     
  355.     case Axes:
  356.     XtSetArg(wargs[n], XtNleftBitmap, 
  357.          BWQueryAxes(bitmap_widget) ? check_mark : None); n++;
  358.     break;
  359.     
  360.     case Stippled:
  361.     XtSetArg(wargs[n], XtNleftBitmap, 
  362.          BWQueryStippled(bitmap_widget) ? check_mark : None); n++;
  363.     break;
  364.     
  365.     case Proportional:
  366.     XtSetArg(wargs[n], XtNleftBitmap, 
  367.          BWQueryProportional(bitmap_widget) ? check_mark : None); n++;
  368.     break;
  369.     
  370.     case Zoom:
  371.     XtSetArg(wargs[n], XtNleftBitmap, 
  372.          BWQueryZooming(bitmap_widget) ? check_mark : None); n++;
  373.     break;
  374.  
  375.     case Copy:
  376.     case Cut:
  377.     XtSetArg(wargs[n], XtNsensitive, BWQueryMarked(bitmap_widget)); n++;
  378.     break;
  379.  
  380.     case Paste:
  381.     XtSetArg(wargs[n], XtNsensitive, 
  382.          BWQuerySelection(bitmap_widget, dummy)); n++;
  383.     break;
  384.  
  385.     default:
  386.     return;
  387.     }
  388.     
  389.     XtSetValues(w, wargs, n);
  390. }
  391.  
  392. /* ARGSUSED */
  393. void FixMenu(w, event)
  394.     Widget w;
  395.     XEvent *event;
  396. {
  397.     int i;
  398.  
  399.     btime = event->xbutton.time;
  400.     
  401.     for (i = 0; i < XtNumber(edit_menu); i++)
  402.     FixEntry(edit_menu[i].widget, &edit_menu[i].id);
  403. }
  404.  
  405. static int zero = 0;
  406. #define Plain  (char *)&zero,sizeof(int)
  407. /* ARGSUSED */
  408. void TheCallback(w, clientData, callData)
  409.      Widget w;           /* not used */
  410.      XtPointer clientData, callData;
  411. {
  412.     int *id = (int *)clientData;
  413.     switch (*id) {
  414.     
  415.     case New:
  416.       DoNew();
  417.       break;
  418.  
  419.     case Load:
  420.       DoLoad();
  421.       break;
  422.     
  423.     case Insert:
  424.       DoInsert();
  425.       break;
  426.     
  427.     case Save:
  428.       DoSave();
  429.       break;
  430.     
  431.     case SaveAs:
  432.       DoSaveAs();
  433.       break;
  434.     
  435.     case Resize:
  436.       DoResize();
  437.       break;
  438.  
  439.     case Rescale:
  440.       DoRescale();
  441.       break;
  442.  
  443.     case Filename:
  444.       DoFilename();
  445.       break;
  446.  
  447.     case Basename:
  448.       DoBasename();
  449.       break;
  450.     
  451.     case Image:
  452.       SwitchImage();
  453.       break;
  454.  
  455.     case Grid:
  456.       SwitchGrid();
  457.       break;
  458.     
  459.     case Dashed:
  460.       SwitchDashed();
  461.       break;
  462.  
  463.     case Axes:
  464.       SwitchAxes();
  465.       break;    
  466.  
  467.     case Stippled:
  468.       SwitchStippled();
  469.       break;
  470.       
  471.     case Proportional:
  472.       SwitchProportional();
  473.       break;
  474.         
  475.     case Zoom:
  476.       SwitchZoom();
  477.       break;
  478.       
  479.     case Cut:
  480.       DoCut();
  481.       break;
  482.       
  483.     case Copy:
  484.       DoCopy();
  485.       break;
  486.       
  487.     case Paste:
  488.       DoPaste();
  489.       break;
  490.     
  491.     case Clear:
  492.     BWStoreToBuffer(bitmap_widget);
  493.     BWClear(bitmap_widget);
  494.     BWChangeNotify(bitmap_widget, NULL, NULL);
  495.     BWSetChanged(bitmap_widget);
  496.     break;
  497.     
  498.     case Set:
  499.     BWStoreToBuffer(bitmap_widget);
  500.     BWSet(bitmap_widget);
  501.     BWChangeNotify(bitmap_widget, NULL, NULL);
  502.     BWSetChanged(bitmap_widget);
  503. break;
  504.     
  505.     case Invert:
  506.     BWStoreToBuffer(bitmap_widget);
  507.     BWInvert(bitmap_widget);
  508.     BWChangeNotify(bitmap_widget, NULL, NULL);
  509.     BWSetChanged(bitmap_widget);
  510.     break;
  511.  
  512.     case Mark:
  513.         BWRemoveAllRequests(bitmap_widget);
  514.         BWEngageRequest(bitmap_widget, MarkRequest, True, Plain);
  515.         break;
  516.  
  517.     case Unmark:
  518.         BWUnmark(bitmap_widget);
  519.         break;
  520.  
  521.     case CopyImm:
  522.     BWRemoveAllRequests(bitmap_widget);
  523.     if (BWQueryMarked(bitmap_widget)) {
  524.         BWAddRequest(bitmap_widget, MarkRequest, False, Plain);
  525.         BWEngageRequest(bitmap_widget, CopyRequest, True, Plain);
  526.     }
  527.     else {
  528.         BWEngageRequest(bitmap_widget, MarkRequest, False, Plain);
  529.         BWAddRequest(bitmap_widget, CopyRequest, True, Plain);
  530.     }
  531.     break;
  532.     
  533.     case MoveImm:
  534.     BWRemoveAllRequests(bitmap_widget);
  535.     if (BWQueryMarked(bitmap_widget)) {
  536.         BWAddRequest(bitmap_widget, MarkRequest, False, Plain);
  537.         BWEngageRequest(bitmap_widget, MoveRequest, True, Plain);
  538.     }
  539.     else {
  540.         BWEngageRequest(bitmap_widget, MarkRequest, False, Plain);
  541.         BWAddRequest(bitmap_widget, MoveRequest, True, Plain);
  542.     }
  543.     break;
  544.         
  545.     case Up:
  546.     BWStoreToBuffer(bitmap_widget);
  547.     BWUp(bitmap_widget);
  548.     BWChangeNotify(bitmap_widget, NULL, NULL);
  549.     BWSetChanged(bitmap_widget);
  550.     break;
  551.     
  552.     case Down:
  553.     BWStoreToBuffer(bitmap_widget);
  554.     BWDown(bitmap_widget);
  555.     BWChangeNotify(bitmap_widget, NULL, NULL);
  556.     BWSetChanged(bitmap_widget);
  557.     break;
  558.     
  559.     case Left:
  560.     BWStoreToBuffer(bitmap_widget);
  561.     BWLeft(bitmap_widget);
  562.     BWChangeNotify(bitmap_widget, NULL, NULL);
  563.     BWSetChanged(bitmap_widget);
  564.     break;
  565.     
  566.     case Right:
  567.     BWStoreToBuffer(bitmap_widget);
  568.     BWRight(bitmap_widget);
  569.     BWChangeNotify(bitmap_widget, NULL, NULL);
  570.     BWSetChanged(bitmap_widget);
  571.     break;
  572.     
  573.     case Fold:
  574.     BWStoreToBuffer(bitmap_widget);
  575.     BWFold(bitmap_widget);
  576.     BWChangeNotify(bitmap_widget, NULL, NULL);
  577.     BWSetChanged(bitmap_widget);
  578.     break;
  579.     
  580.     case FlipHoriz:
  581.     BWStoreToBuffer(bitmap_widget);
  582.     BWFlipHoriz(bitmap_widget);
  583.     BWChangeNotify(bitmap_widget, NULL, NULL);
  584.     BWSetChanged(bitmap_widget);
  585.     break;
  586.     
  587.     case FlipVert:
  588.     BWStoreToBuffer(bitmap_widget);
  589.     BWFlipVert(bitmap_widget);
  590.     BWChangeNotify(bitmap_widget, NULL, NULL);
  591.     BWSetChanged(bitmap_widget);
  592.     break;
  593.     
  594.     case RotateRight:
  595.     BWStoreToBuffer(bitmap_widget);
  596.     BWRotateRight(bitmap_widget);
  597.     BWChangeNotify(bitmap_widget, NULL, NULL);
  598.     BWSetChanged(bitmap_widget);
  599.     break;
  600.     
  601.     case RotateLeft:
  602.     BWStoreToBuffer(bitmap_widget);
  603.     BWRotateLeft(bitmap_widget);
  604.     BWChangeNotify(bitmap_widget, NULL, NULL);
  605.     BWSetChanged(bitmap_widget);
  606.     break;
  607.     
  608.     case Point:
  609.     BWRemoveAllRequests(bitmap_widget);
  610.     BWEngageRequest(bitmap_widget, PointRequest, True, Plain);
  611.     break;
  612.  
  613.     case Curve:
  614.     BWRemoveAllRequests(bitmap_widget);
  615.     BWEngageRequest(bitmap_widget, CurveRequest, True, Plain);
  616.     break;
  617.     
  618.     case Line:
  619.     BWRemoveAllRequests(bitmap_widget);
  620.     BWEngageRequest(bitmap_widget, LineRequest, True, Plain);
  621.     break;
  622.     
  623.     case Rectangle:
  624.     BWRemoveAllRequests(bitmap_widget);
  625.     BWEngageRequest(bitmap_widget, RectangleRequest, True, Plain);
  626.     break;
  627.     
  628.     case FilledRectangle:
  629.     BWRemoveAllRequests(bitmap_widget);
  630.     BWEngageRequest(bitmap_widget, FilledRectangleRequest, True, Plain);
  631.     break;
  632.     
  633.     case Circle:
  634.     BWRemoveAllRequests(bitmap_widget);
  635.     BWEngageRequest(bitmap_widget, CircleRequest, True, Plain);
  636.     break;
  637.     
  638.     case FilledCircle:
  639.     BWRemoveAllRequests(bitmap_widget);
  640.     BWEngageRequest(bitmap_widget, FilledCircleRequest, True, Plain);
  641.     break;
  642.     
  643.     case FloodFill:
  644.     BWRemoveAllRequests(bitmap_widget);
  645.     BWEngageRequest(bitmap_widget, FloodFillRequest, True, Plain);
  646.     break;
  647.     
  648.     case SetHotSpot:
  649.     BWRemoveAllRequests(bitmap_widget);
  650.     BWEngageRequest(bitmap_widget, HotSpotRequest, True, Plain);
  651.     break;
  652.     
  653.     case ClearHotSpot:
  654.     BWStoreToBuffer(bitmap_widget);
  655.     BWClearHotSpot(bitmap_widget);
  656.     BWChangeNotify(bitmap_widget, NULL, NULL);
  657.     BWSetChanged(bitmap_widget);
  658.     break;
  659.  
  660.     case Undo:
  661.     BWUndo(bitmap_widget);
  662.     BWChangeNotify(bitmap_widget, NULL, NULL);
  663.     BWSetChanged(bitmap_widget);
  664.     break;    
  665.  
  666.     case Quit:
  667.       DoQuit();
  668.       break;    
  669.     } /* don't add anything below this line */
  670. }
  671.  
  672. /* ARGSUSED */
  673.  
  674. void SwitchImage()
  675. {
  676.   if (image_visible) {
  677.     XtPopdown(image_shell);
  678.     image_visible = False;
  679.   }
  680.   else {
  681.     Position image_x, image_y;
  682.     int n;
  683.     Arg wargs[3];
  684.     
  685.     XtTranslateCoords(bitmap_widget,
  686.               10, 10, &image_x, &image_y);
  687.     
  688.     n = 0;
  689.     XtSetArg(wargs[n], XtNx, image_x); n++;
  690.     XtSetArg(wargs[n], XtNy, image_y); n++;
  691.     XtSetValues(image_shell, wargs, n);
  692.     
  693.     image_visible = True;
  694.     
  695.     FixImage();
  696.     XtPopup(image_shell, XtGrabNone);
  697.     FixImage();
  698.   }
  699. }
  700.  
  701. void SwitchGrid()
  702. {
  703.   BWSwitchGrid(bitmap_widget);
  704. }
  705.  
  706. void SwitchDashed()
  707. {
  708.   BWSwitchDashed(bitmap_widget);
  709. }
  710.  
  711. void SwitchAxes()
  712. {
  713.   BWSwitchAxes(bitmap_widget);
  714. }
  715.  
  716. void SwitchStippled()
  717. {
  718.   BWSwitchStippled(bitmap_widget); 
  719. }
  720.  
  721. void SwitchProportional()
  722. {
  723.   BWSwitchProportional(bitmap_widget);
  724. }
  725.  
  726. void SwitchZoom()
  727. {
  728.   if (BWQueryZooming(bitmap_widget)) {
  729.     BWZoomOut(bitmap_widget);
  730.     BWChangeNotify(bitmap_widget, NULL, NULL);
  731.   }
  732.   else {
  733.     if (BWQueryMarked(bitmap_widget)) {
  734.       BWStoreToBuffer(bitmap_widget);
  735.       BWZoomMarked(bitmap_widget);
  736.       BWChangeNotify(bitmap_widget, NULL, NULL);
  737.     }
  738.     else {
  739.       BWEngageRequest(bitmap_widget, ZoomInRequest, False, Plain);
  740.     }
  741.   }
  742. }
  743.  
  744. void DoCut()
  745. {
  746.   BWStore(bitmap_widget);
  747.   BWStoreToBuffer(bitmap_widget);
  748.   BWClearMarked(bitmap_widget);
  749.   BWUnmark(bitmap_widget);
  750.   BWChangeNotify(bitmap_widget, NULL, NULL);
  751.   BWSetChanged(bitmap_widget);
  752. }
  753.  
  754. void DoCopy()
  755. {
  756.   BWStore(bitmap_widget);
  757.   BWUnmark(bitmap_widget);
  758. }
  759.  
  760. void DoPaste()
  761. {
  762.   BWRequestSelection(bitmap_widget, btime, TRUE); 
  763.   BWEngageRequest(bitmap_widget, RestoreRequest, False, Plain);
  764. }
  765.  
  766. void DoNew()
  767. {
  768.   BWGetFilename(bitmap_widget, &filename);
  769.   if (PopupDialog(input_dialog, "New file:",
  770.           filename, &filename, XtGrabExclusive) == Okay) {
  771.     BWChangeFilename(bitmap_widget, filename);
  772.     BWChangeBasename(bitmap_widget, filename);
  773.     BWStoreToBuffer(bitmap_widget);
  774.     BWClear(bitmap_widget);
  775.     BWClearHotSpot(bitmap_widget);
  776.     BWChangeNotify(bitmap_widget, NULL, NULL);
  777.     BWClearChanged(bitmap_widget);
  778.     BWUnmark(bitmap_widget);
  779.     FixStatus();
  780.   }
  781. }
  782.  
  783. void DoLoad()
  784. {
  785.   if (BWQueryChanged(bitmap_widget)) {
  786.     BWGetFilename(bitmap_widget, &filename);
  787.   RetryLoadSave:
  788.     switch (PopupDialog(qsave_dialog, "Save file before loading?",
  789.             filename, &filename, XtGrabExclusive)) {
  790.     case Yes:
  791.       if (BWWriteFile(bitmap_widget, filename, NULL)
  792.       != BitmapSuccess) {
  793.     sprintf(message, "Can't write file: %s", filename);
  794.     if (PopupDialog(error_dialog, message,
  795.             NULL, NULL, XtGrabExclusive) == Retry)
  796.       goto RetryLoadSave;
  797.       }
  798.       break;
  799.       
  800.     case Cancel:
  801.       return;
  802.     }
  803.   }
  804.   BWGetFilepath(bitmap_widget, &filename);
  805.  RetryLoad:
  806.   if (PopupDialog(input_dialog, "Load file:",
  807.           filename, &filename, XtGrabExclusive) == Okay) {
  808.     if (BWReadFile(bitmap_widget, filename, NULL) != BitmapSuccess) {
  809.       sprintf(message, "Can't read file: %s", filename);
  810.       if (PopupDialog(error_dialog, message,
  811.               NULL, NULL, XtGrabExclusive) == Retry)
  812.     goto RetryLoad;
  813.     }
  814.     else {
  815.       BWChangeNotify(bitmap_widget, NULL, NULL);
  816.       BWClearChanged(bitmap_widget);
  817.       FixStatus();
  818.     }
  819.   }
  820. }
  821.  
  822. void DoInsert()
  823. {
  824.   BWGetFilepath(bitmap_widget, &filename);
  825.  RetryInsert:
  826.   if (PopupDialog(input_dialog, "Insert file:",
  827.           filename, &filename, XtGrabExclusive) == Okay) {
  828.     if (BWStoreFile(bitmap_widget, filename, NULL) != BitmapSuccess) {
  829.       sprintf(message, "Can't read file: %s", filename);
  830.       if (PopupDialog(error_dialog, message,
  831.               NULL, NULL, XtGrabExclusive) == Retry)
  832.     goto RetryInsert;
  833.     }
  834.     else {
  835.       BWEngageRequest(bitmap_widget, RestoreRequest, False, Plain);
  836.     }
  837.   }
  838. }
  839.  
  840. void DoSave()
  841. {
  842.   BWGetFilename(bitmap_widget, &filename);
  843.   if (!strcmp(filename, "")) 
  844.     DoSaveAs();
  845.   else if (BWWriteFile(bitmap_widget, NULL, NULL) != BitmapSuccess) {
  846.     sprintf(message, "Can't write file: %s", filename);
  847.     if (PopupDialog(error_dialog, message,
  848.             NULL, NULL, XtGrabExclusive) == Retry) 
  849.       DoSaveAs();
  850.   }
  851.   else {
  852.     BWClearChanged(bitmap_widget);
  853.   }
  854. }
  855.  
  856. void DoSaveAs()
  857. {
  858.   BWGetFilename(bitmap_widget, &filename);
  859.  RetrySave:
  860.   if (PopupDialog(input_dialog, "Save file:",
  861.           filename, &filename, XtGrabExclusive) == Okay) {
  862.     if (BWWriteFile(bitmap_widget, filename, NULL) != BitmapSuccess) {
  863.       sprintf(message, "Can't write file: %s", filename);
  864.       if (PopupDialog(error_dialog, message,
  865.               NULL, NULL, XtGrabExclusive) == Retry)
  866.     goto RetrySave;
  867.     }
  868.     else {
  869.       BWClearChanged(bitmap_widget);
  870.       FixStatus();
  871.     }
  872.   }
  873. }
  874.  
  875. void DoResize()
  876. {
  877.   Dimension width, height;
  878.   format = "";
  879.  RetryResize:
  880.   if (PopupDialog(input_dialog, "Resize to WIDTHxHEIGHT:",
  881.           format, &format, XtGrabExclusive) == Okay) {
  882.     if (BWParseSize(format, &width, &height)) {
  883.       BWResize(bitmap_widget, width, height);
  884.       BWChangeNotify(bitmap_widget, NULL, NULL);
  885.       BWSetChanged(bitmap_widget);
  886.       FixStatus();
  887.     }
  888.     else {
  889.       sprintf(message, "Wrong format: %s", format);
  890.       if (PopupDialog(error_dialog, message,
  891.               NULL, NULL, XtGrabExclusive) == Retry)
  892.     goto RetryResize;
  893.     }
  894.   }
  895. }
  896.  
  897. void DoRescale()
  898. {
  899.   Dimension width, height;
  900.  
  901.   format = "";
  902.  RetryRescale:
  903.   if (PopupDialog(input_dialog, "Rescale to WIDTHxHEIGHT:",
  904.           format, &format, XtGrabExclusive) == Okay) {
  905.     if (BWParseSize(format, &width, &height)) {
  906.       BWRescale(bitmap_widget, width, height);
  907.       BWChangeNotify(bitmap_widget, NULL, NULL);
  908.       BWSetChanged(bitmap_widget);
  909.       FixStatus();
  910.     }
  911.     else {
  912.       sprintf(message, "Wrong format: %s", format);
  913.       if (PopupDialog(error_dialog, message,
  914.               NULL, NULL, XtGrabExclusive) == Retry)
  915.     goto RetryRescale;
  916.     }
  917.   }
  918. }
  919.  
  920. void DoFilename()
  921. {
  922.   BWGetFilename(bitmap_widget, &filename);
  923.   if (PopupDialog(input_dialog, "Change filename:",
  924.           filename, &filename, XtGrabExclusive) == Okay) {
  925.     BWChangeFilename(bitmap_widget, filename);
  926.     FixStatus();
  927.   }
  928. }
  929.  
  930. void DoBasename()
  931. {  
  932.   BWGetBasename(bitmap_widget, &basename);
  933.   if (PopupDialog(input_dialog, "Change basename:",
  934.           basename, &basename, XtGrabExclusive) == Okay) {
  935.     BWChangeBasename(bitmap_widget, basename);
  936.     FixStatus();
  937.   }
  938. }
  939.  
  940. void DoQuit(w) /* ARGSUSED */
  941.     Widget w;
  942. {
  943.   if (BWQueryChanged(bitmap_widget)) {
  944.     BWGetFilename(bitmap_widget, &filename);
  945.   RetryQuit:
  946.     switch (PopupDialog(qsave_dialog, "Save file before quitting?",
  947.             filename, &filename, XtGrabExclusive)) {
  948.     case Yes:
  949.       if (BWWriteFile(bitmap_widget, filename, NULL) 
  950.       != BitmapSuccess) {
  951.     sprintf(message, "Can't write file: %s", filename);
  952.     if (PopupDialog(error_dialog, message, 
  953.             NULL, NULL, XtGrabExclusive) == Retry) 
  954.       goto RetryQuit;
  955.     else return;
  956.       }
  957.       break;
  958.       
  959.     case Cancel:
  960.       return;
  961.     }
  962.   }
  963.   exit(0);
  964. }
  965.  
  966. void main(argc, argv)
  967.     int    argc;
  968.     char  *argv[];
  969. {
  970.     int i, n;
  971.     Arg wargs[2];
  972.     Widget w;
  973.     Widget radio_group; caddr_t radio_data;
  974.     
  975.     top_widget = XtInitialize(NULL, "Bitmap", 
  976.                   options, XtNumber(options), &argc, argv);
  977.  
  978.     if (argc > 2) {
  979.     fprintf(stderr, usage);
  980.     exit (0);
  981.     }
  982.  
  983.     check_mark = XCreateBitmapFromData(XtDisplay(top_widget),
  984.                       RootWindowOfScreen(XtScreen(top_widget)),
  985.                       (char *) xlogo16_bits, 
  986.                       xlogo16_width, 
  987.                       xlogo16_height);
  988.  
  989.     XtAddActions(actions_table, XtNumber(actions_table));
  990.     XtOverrideTranslations
  991.       (top_widget,
  992.        XtParseTranslationTable("<Message>WM_PROTOCOLS: do-quit()"));
  993.  
  994.     parent_widget = XtCreateManagedWidget("parent", panedWidgetClass,
  995.                      top_widget, NULL, 0);
  996.  
  997.     formy_widget = XtCreateManagedWidget("formy", formWidgetClass,
  998.                        parent_widget, NULL, 0);
  999.  
  1000.     fileMenu_widget = XtCreatePopupShell("fileMenu", 
  1001.                      simpleMenuWidgetClass, 
  1002.                      formy_widget, NULL, 0);
  1003.     
  1004.     fileButton_widget = XtCreateManagedWidget("fileButton",
  1005.                           menuButtonWidgetClass, 
  1006.                           formy_widget, NULL, 0);
  1007.     for (i = 0; i < XtNumber(file_menu); i++) {
  1008.     w = XtCreateManagedWidget(file_menu[i].name, 
  1009.                   (file_menu[i].trap ? 
  1010.                    smeBSBObjectClass : smeLineObjectClass),
  1011.                   fileMenu_widget, NULL, 0),
  1012.     XtAddCallback(w,
  1013.               XtNcallback,
  1014.               TheCallback,
  1015.               (XtPointer)&file_menu[i].id);
  1016.     
  1017.     file_menu[i].widget = w;
  1018.     }
  1019.         
  1020.     editMenu_widget = XtCreatePopupShell("editMenu", 
  1021.                      simpleMenuWidgetClass, 
  1022.                      formy_widget, NULL, 0);
  1023.     
  1024.     editButton_widget = XtCreateManagedWidget("editButton", 
  1025.                           menuButtonWidgetClass, 
  1026.                           formy_widget, NULL, 0);
  1027.  
  1028.     for (i = 0; i < XtNumber(edit_menu); i++) {
  1029.     w = XtCreateManagedWidget(edit_menu[i].name, 
  1030.                   (edit_menu[i].trap ? 
  1031.                    smeBSBObjectClass : smeLineObjectClass),
  1032.                   editMenu_widget, NULL, 0),
  1033.     XtAddCallback(w,
  1034.               XtNcallback,
  1035.               TheCallback,
  1036.               (XtPointer)&edit_menu[i].id);
  1037.     
  1038.     edit_menu[i].widget = w;
  1039.     }
  1040.  
  1041.     status_widget = XtCreateManagedWidget("status", labelWidgetClass,
  1042.                       formy_widget, NULL, 0);
  1043.  
  1044.     pane_widget = XtCreateManagedWidget("pane", panedWidgetClass,
  1045.                     parent_widget, NULL, 0);
  1046.  
  1047.     form_widget = XtCreateManagedWidget("form", formWidgetClass, 
  1048.                     pane_widget, NULL, 0);
  1049.         
  1050.     for (i = 0; i < XtNumber(buttons); i++) {
  1051.     w = XtCreateManagedWidget(buttons[i].name, 
  1052.                   (buttons[i].trap ? 
  1053.                    toggleWidgetClass : commandWidgetClass),
  1054.                   form_widget, NULL, 0);
  1055.  
  1056.     XtAddCallback(w,
  1057.               XtNcallback,
  1058.               TheCallback,
  1059.               (XtPointer)&buttons[i].id);
  1060.  
  1061.     buttons[i].widget = w;
  1062.  
  1063.     if (buttons[i].id == Point) {
  1064.         radio_group = buttons[i].widget;
  1065.         radio_data  = buttons[i].name;
  1066.     }
  1067.     }
  1068.     bitmap_widget = XtCreateManagedWidget("bitmap", bitmapWidgetClass,
  1069.                       pane_widget, NULL, 0);
  1070.     XtRealizeWidget(top_widget);
  1071.     if (argc > 1)
  1072.       if (BWReadFile(bitmap_widget, argv[1], NULL)) 
  1073.  
  1074.     wm_delete_window = XInternAtom(XtDisplay(top_widget), "WM_DELETE_WINDOW",
  1075.                    False);
  1076.     (void) XSetWMProtocols (XtDisplay(top_widget), XtWindow(top_widget),
  1077.                             &wm_delete_window, 1);
  1078.  
  1079.     
  1080.     image_shell = XtCreatePopupShell("image", transientShellWidgetClass,
  1081.                      top_widget, NULL, 0);
  1082.  
  1083.     box_widget = XtCreateManagedWidget("box", boxWidgetClass,
  1084.                        image_shell, NULL, 0);
  1085.  
  1086.     normal_image_widget = XtCreateManagedWidget("normalImage", 
  1087.                         labelWidgetClass,
  1088.                         box_widget, NULL, 0);
  1089.  
  1090.     inverted_image_widget = XtCreateManagedWidget("invertedImage", 
  1091.                           labelWidgetClass,
  1092.                           box_widget, NULL, 0);
  1093.     
  1094.     n=0;
  1095.     XtSetArg(wargs[n], XtNbitmap, BWGetUnzoomedPixmap(bitmap_widget)); n++;
  1096.     XtSetValues(normal_image_widget, wargs, n);
  1097.     XtSetValues(inverted_image_widget, wargs, n);
  1098.     
  1099.     XtRealizeWidget(image_shell);
  1100.  
  1101.     BWNotify(bitmap_widget, FixUp);
  1102.  
  1103.     FixStatus();
  1104.  
  1105.     input_dialog = CreateDialog(top_widget, "input", Okay | Cancel);
  1106.     error_dialog = CreateDialog(top_widget, "error", Abort | Retry);    
  1107.     qsave_dialog = CreateDialog(top_widget, "qsave", Yes | No | Cancel);
  1108.  
  1109.     XawToggleSetCurrent(radio_group, radio_data);
  1110.     BWEngageRequest(bitmap_widget, PointRequest, True, Plain);
  1111.  
  1112.     XtMainLoop();
  1113. }
  1114.